home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / UNIX / PASCAL / PTOC / PTC_C.3 < prev    next >
Text File  |  1992-11-23  |  31KB  |  1,501 lines
  1.                 break ;
  2.               default:
  3.                 Caseerror(Line);
  4.             }
  5.             nextsymbol(*((symset *)Conset[91]));
  6.             break ;
  7.           case nparproc:
  8.             tq->U.V15.tparid = newid(currsym.U.V1.vid);
  9.             nextsymbol(*((symset *)Conset[92]));
  10.             if (currsym.st == slpar) {
  11.                 enterscope((declptr)NIL);
  12.                 tq->U.V15.tparparm = psubpar();
  13.                 nextsymbol(*((symset *)Conset[93]));
  14.                 leavescope();
  15.             } else
  16.                 tq->U.V15.tparparm = (struct S61 *)NIL;
  17.             tq->U.V15.tpartyp = (struct S61 *)NIL;
  18.             break ;
  19.           case nparfunc:
  20.             tq->U.V15.tparid = newid(currsym.U.V1.vid);
  21.             nextsymbol(*((symset *)Conset[94]));
  22.             if (currsym.st == slpar) {
  23.                 enterscope((declptr)NIL);
  24.                 tq->U.V15.tparparm = psubpar();
  25.                 nextsymbol(*((symset *)Conset[95]));
  26.                 leavescope();
  27.             } else
  28.                 tq->U.V15.tparparm = (struct S61 *)NIL;
  29.             nextsymbol(*((symset *)Conset[96]));
  30.             tq->U.V15.tpartyp = oldid(currsym.U.V1.vid, lidentifier);
  31.             nextsymbol(*((symset *)Conset[97]));
  32.             break ;
  33.           default:
  34.             Caseerror(Line);
  35.         }
  36.     } while (!(currsym.st == srpar));
  37.     R142 = tp;
  38.     return R142;
  39. }
  40.  
  41.  treeptr
  42. plabstmt()
  43. {
  44.     register treeptr    R143;
  45.     treeptr    tp;
  46.  
  47.     nextsymbol(*((symset *)Conset[98]));
  48.     if (currsym.st == sinteger) {
  49.         tp = mknode(nlabstmt);
  50.         tp->U.V25.tlabno = oldlbl(true);
  51.         nextsymbol(*((symset *)Conset[99]));
  52.         nextsymbol(*((symset *)Conset[100]));
  53.         tp->U.V25.tstmt = pstmt();
  54.     } else
  55.         tp = pstmt();
  56.     R143 = tp;
  57.     return R143;
  58. }
  59.  
  60.  treeptr
  61. pstmt()
  62. {
  63.     register treeptr    R144;
  64.     treeptr    tp;
  65.  
  66.     switch (currsym.st) {
  67.       case sid:
  68.         tp = psimple();
  69.         break ;
  70.       case sif:
  71.         tp = pif();
  72.         break ;
  73.       case swhile:
  74.         tp = pwhile();
  75.         break ;
  76.       case srepeat:
  77.         tp = prepeat();
  78.         break ;
  79.       case sfor:
  80.         tp = pfor();
  81.         break ;
  82.       case scase:
  83.         tp = pcase();
  84.         break ;
  85.       case swith:
  86.         tp = pwith();
  87.         break ;
  88.       case sbegin:
  89.         tp = pbegin(true);
  90.         break ;
  91.       case sgoto:
  92.         tp = pgoto();
  93.         break ;
  94.       case send:  case selse:  case suntil:  case ssemic:
  95.         tp = mknode(nempty);
  96.         break ;
  97.       default:
  98.         Caseerror(Line);
  99.     }
  100.     R144 = tp;
  101.     return R144;
  102. }
  103.  
  104.  treeptr
  105. psimple()
  106. {
  107.     register treeptr    R145;
  108.     treeptr    tq, tp;
  109.  
  110.     tp = pvariable(oldid(currsym.U.V1.vid, lidentifier));
  111.     if (currsym.st == sassign) {
  112.         tq = mknode(nassign);
  113.         tq->U.V27.tlhs = tp;
  114.         tq->U.V27.trhs = pexpr((treeptr)NIL);
  115.         tp = tq;
  116.     }
  117.     R145 = tp;
  118.     return R145;
  119. }
  120.  
  121.  treeptr
  122. pvariable(varptr)
  123.     treeptr    varptr;
  124. {
  125.     register treeptr    R146;
  126.     treeptr    tp, tq;
  127.  
  128.     nextsymbol(*((symset *)Conset[101]));
  129.     if (Member((unsigned)(currsym.st), Conset[102])) {
  130.         switch (currsym.st) {
  131.           case slpar:
  132.             tp = mknode(ncall);
  133.             tp->U.V30.tcall = varptr;
  134.             tq = (struct S61 *)NIL;
  135.             do {
  136.                 if (tq == (struct S61 *)NIL) {
  137.                     tq = pexpr((treeptr)NIL);
  138.                     tp->U.V30.taparm = tq;
  139.                 } else {
  140.                     tq->tnext = pexpr((treeptr)NIL);
  141.                     tq = tq->tnext;
  142.                 }
  143.             } while (!(currsym.st == srpar));
  144.             break ;
  145.           case slbrack:
  146.             tq = varptr;
  147.             do {
  148.                 tp = mknode(nindex);
  149.                 tp->U.V39.tvariable = tq;
  150.                 tp->U.V39.toffset = pexpr((treeptr)NIL);
  151.                 tq = tp;
  152.             } while (!(currsym.st == srbrack));
  153.             break ;
  154.           case sdot:
  155.             tp = mknode(nselect);
  156.             tp->U.V40.trecord = varptr;
  157.             nextsymbol(*((symset *)Conset[103]));
  158.             tq = typeof(varptr);
  159.             enterscope(tq->U.V21.trscope);
  160.             tp->U.V40.tfield = oldid(currsym.U.V1.vid, lfield);
  161.             leavescope();
  162.             break ;
  163.           case sarrow:
  164.             tp = mknode(nderef);
  165.             tp->U.V42.texps = varptr;
  166.             break ;
  167.           default:
  168.             Caseerror(Line);
  169.         }
  170.         tp = pvariable(tp);
  171.     } else {
  172.         tp = varptr;
  173.         if (tp->tt == nid) {
  174.             tq = idup(tp);
  175.             if (tq != (struct S61 *)NIL)
  176.                 if (Member((unsigned)(tq->tt), Conset[104])) {
  177.                     tp = mknode(ncall);
  178.                     tp->U.V30.tcall = varptr;
  179.                     tp->U.V30.taparm = (struct S61 *)NIL;
  180.                 }
  181.         }
  182.     }
  183.     R146 = tp;
  184.     return R146;
  185. }
  186.  
  187. treeptr pexpr();
  188.  
  189.  treeptr
  190. padjust(tu, tr)
  191.     treeptr    tu, tr;
  192. {
  193.     register treeptr    R148;
  194.  
  195.     if (pprio.A[(int)(tu->tt) - (int)(nassign)] >= pprio.A[(int)(tr->tt) - (int)(nassign)]) {
  196.         if (Member((unsigned)(tr->tt), Conset[105]))
  197.             tr->U.V42.texps = padjust(tu, tr->U.V42.texps);
  198.         else
  199.             tr->U.V41.texpl = padjust(tu, tr->U.V41.texpl);
  200.         R148 = tr;
  201.     } else {
  202.         if (Member((unsigned)(tu->tt), Conset[106]))
  203.             tu->U.V42.texps = tr;
  204.         else
  205.             tu->U.V41.texpr = tr;
  206.         R148 = tu;
  207.     }
  208.     return R148;
  209. }
  210.  
  211.  treeptr
  212. pexpr(tnp)
  213.     treeptr    tnp;
  214. {
  215.     register treeptr    R147;
  216.     treeptr    tp, tq;
  217.     treetyp    nt;
  218.     boolean    next;
  219.  
  220.     nextsymbol(*((symset *)Conset[107]));
  221.     next = true;
  222.     switch (currsym.st) {
  223.       case splus:
  224.         tp = mknode(nuplus);
  225.         tp->U.V42.texps = (struct S61 *)NIL;
  226.         tp = pexpr(tp);
  227.         next = false;
  228.         break ;
  229.       case sminus:
  230.         tp = mknode(numinus);
  231.         tp->U.V42.texps = (struct S61 *)NIL;
  232.         tp = pexpr(tp);
  233.         next = false;
  234.         break ;
  235.       case snot:
  236.         tp = mknode(nnot);
  237.         tp->U.V42.texps = (struct S61 *)NIL;
  238.         tp = pexpr(tp);
  239.         next = false;
  240.         break ;
  241.       case schar:  case sinteger:  case sreal:  case sstring:
  242.         tp = mklit();
  243.         break ;
  244.       case snil:
  245.         usenilp = true;
  246.         tp = mknode(nnil);
  247.         break ;
  248.       case sid:
  249.         tp = pvariable(oldid(currsym.U.V1.vid, lidentifier));
  250.         next = false;
  251.         break ;
  252.       case slpar:
  253.         tp = mknode(nuplus);
  254.         tp->U.V42.texps = pexpr((treeptr)NIL);
  255.         break ;
  256.       case slbrack:
  257.         usesets = true;
  258.         tp = mknode(nset);
  259.         tp->U.V42.texps = (struct S61 *)NIL;
  260.         tq = (struct S61 *)NIL;
  261.         do {
  262.             if (tq == (struct S61 *)NIL) {
  263.                 tq = pexpr((treeptr)NIL);
  264.                 tp->U.V42.texps = tq;
  265.             } else {
  266.                 tq->tnext = pexpr((treeptr)NIL);
  267.                 tq = tq->tnext;
  268.             }
  269.         } while (!(currsym.st == srbrack));
  270.         break ;
  271.       case srbrack:
  272.         tp = mknode(nempty);
  273.         next = false;
  274.         break ;
  275.       default:
  276.         Caseerror(Line);
  277.     }
  278.     if (next)
  279.         nextsymbol(*((symset *)Conset[108]));
  280.     switch (currsym.st) {
  281.       case sdotdot:
  282.         nt = nrange;
  283.         break ;
  284.       case splus:
  285.         nt = nplus;
  286.         break ;
  287.       case sminus:
  288.         nt = nminus;
  289.         break ;
  290.       case smul:
  291.         nt = nmul;
  292.         break ;
  293.       case sdiv:
  294.         nt = ndiv;
  295.         break ;
  296.       case smod:
  297.         nt = nmod;
  298.         break ;
  299.       case squot:
  300.         defnams.A[(int)(dreal)]->U.V6.lused = true;
  301.         nt = nquot;
  302.         break ;
  303.       case sand:
  304.         nt = nand;
  305.         break ;
  306.       case sor:
  307.         nt = nor;
  308.         break ;
  309.       case sinn:
  310.         nt = nin;
  311.         usesets = true;
  312.         break ;
  313.       case sle:
  314.         nt = nle;
  315.         break ;
  316.       case slt:
  317.         nt = nlt;
  318.         break ;
  319.       case seq:
  320.         nt = neq;
  321.         break ;
  322.       case sge:
  323.         nt = nge;
  324.         break ;
  325.       case sgt:
  326.         nt = ngt;
  327.         break ;
  328.       case sne:
  329.         nt = nne;
  330.         break ;
  331.       case scolon:
  332.         nt = nformat;
  333.         break ;
  334.       case sid:  case schar:  case sinteger:  case sreal:
  335.       case sstring:  case snil:  case ssemic:  case scomma:
  336.       case slpar:  case slbrack:  case srpar:  case srbrack:
  337.       case send:  case suntil:  case sthen:  case selse:
  338.       case sdo:  case sdownto:  case sto:  case sof:
  339.         nt = nnil;
  340.         break ;
  341.       default:
  342.         Caseerror(Line);
  343.     }
  344.     if (Member((unsigned)(nt), Conset[109]))
  345.         defnams.A[(int)(dboolean)]->U.V6.lused = true;
  346.     if (nt != nnil) {
  347.         tq = mknode(nt);
  348.         tq->U.V41.texpl = tp;
  349.         tq->U.V41.texpr = (struct S61 *)NIL;
  350.         tp = pexpr(tq);
  351.     }
  352.     if (tnp != (struct S61 *)NIL)
  353.         tp = padjust(tnp, tp);
  354.     R147 = tp;
  355.     return R147;
  356. }
  357.  
  358.  treeptr
  359. pcase()
  360. {
  361.     register treeptr    R149;
  362.     treeptr    tp, tq, tv;
  363.  
  364.     tp = mknode(ncase);
  365.     tp->U.V35.tcasxp = pexpr((treeptr)NIL);
  366.     checksymbol(*((symset *)Conset[110]));
  367.     tq = (struct S61 *)NIL;
  368.     do {
  369.         if (tq == (struct S61 *)NIL) {
  370.             tq = mknode(nchoise);
  371.             tp->U.V35.tcaslst = tq;
  372.         } else {
  373.             tq->tnext = mknode(nchoise);
  374.             tq = tq->tnext;
  375.         }
  376.         tv = (struct S61 *)NIL;
  377.         do {
  378.             nextsymbol(*((symset *)Conset[111]));
  379.             if (Member((unsigned)(currsym.st), Conset[112]))
  380.                 goto L999;
  381.             if (tv == (struct S61 *)NIL) {
  382.                 tv = pconstant(false);
  383.                 tq->U.V36.tchocon = tv;
  384.             } else {
  385.                 tv->tnext = pconstant(false);
  386.                 tv = tv->tnext;
  387.             }
  388.             nextsymbol(*((symset *)Conset[113]));
  389.         } while (!(currsym.st == scolon));
  390.         tq->U.V36.tchostmt = plabstmt();
  391.     } while (!(currsym.st == send));
  392. L999:
  393.     if (currsym.st == sother) {
  394.         nextsymbol(*((symset *)Conset[114]));
  395.         if (currsym.st == scolon)
  396.             nextsymbol(*((symset *)Conset[115]));
  397.         tp->U.V35.tcasother = pstmt();
  398.     } else {
  399.         tp->U.V35.tcasother = (struct S61 *)NIL;
  400.         usecase = true;
  401.     }
  402.     nextsymbol(*((symset *)Conset[116]));
  403.     R149 = tp;
  404.     return R149;
  405. }
  406.  
  407.  treeptr
  408. pif()
  409. {
  410.     register treeptr    R150;
  411.     treeptr    tp;
  412.  
  413.     tp = mknode(nif);
  414.     tp->U.V31.tifxp = pexpr((treeptr)NIL);
  415.     checksymbol(*((symset *)Conset[117]));
  416.     tp->U.V31.tthen = plabstmt();
  417.     if (currsym.st == selse)
  418.         tp->U.V31.telse = plabstmt();
  419.     else
  420.         tp->U.V31.telse = (struct S61 *)NIL;
  421.     R150 = tp;
  422.     return R150;
  423. }
  424.  
  425.  treeptr
  426. pwhile()
  427. {
  428.     register treeptr    R151;
  429.     treeptr    tp;
  430.  
  431.     tp = mknode(nwhile);
  432.     tp->U.V32.twhixp = pexpr((treeptr)NIL);
  433.     checksymbol(*((symset *)Conset[118]));
  434.     tp->U.V32.twhistmt = plabstmt();
  435.     R151 = tp;
  436.     return R151;
  437. }
  438.  
  439.  treeptr
  440. prepeat()
  441. {
  442.     register treeptr    R152;
  443.     treeptr    tp, tq;
  444.  
  445.     tp = mknode(nrepeat);
  446.     tq = (struct S61 *)NIL;
  447.     do {
  448.         if (tq == (struct S61 *)NIL) {
  449.             tq = plabstmt();
  450.             tp->U.V33.treptstmt = tq;
  451.         } else {
  452.             tq->tnext = plabstmt();
  453.             tq = tq->tnext;
  454.         }
  455.         checksymbol(*((symset *)Conset[119]));
  456.     } while (!(currsym.st == suntil));
  457.     tp->U.V33.treptxp = pexpr((treeptr)NIL);
  458.     R152 = tp;
  459.     return R152;
  460. }
  461.  
  462.  treeptr
  463. pfor()
  464. {
  465.     register treeptr    R153;
  466.     treeptr    tp;
  467.  
  468.     tp = mknode(nfor);
  469.     nextsymbol(*((symset *)Conset[120]));
  470.     tp->U.V34.tforid = oldid(currsym.U.V1.vid, lidentifier);
  471.     nextsymbol(*((symset *)Conset[121]));
  472.     tp->U.V34.tfrom = pexpr((treeptr)NIL);
  473.     checksymbol(*((symset *)Conset[122]));
  474.     tp->U.V34.tincr = (boolean)(currsym.st == sto);
  475.     tp->U.V34.tto = pexpr((treeptr)NIL);
  476.     checksymbol(*((symset *)Conset[123]));
  477.     tp->U.V34.tforstmt = plabstmt();
  478.     R153 = tp;
  479.     return R153;
  480. }
  481.  
  482.  treeptr
  483. pwith()
  484. {
  485.     register treeptr    R154;
  486.     treeptr    tp, tq;
  487.  
  488.     tp = mknode(nwith);
  489.     tq = (struct S61 *)NIL;
  490.     do {
  491.         if (tq == (struct S61 *)NIL) {
  492.             tq = mknode(nwithvar);
  493.             tp->U.V37.twithvar = tq;
  494.         } else {
  495.             tq->tnext = mknode(nwithvar);
  496.             tq = tq->tnext;
  497.         }
  498.         enterscope((declptr)NIL);
  499.         tq->U.V38.tenv = currscope();
  500.         tq->U.V38.texpw = pexpr((treeptr)NIL);
  501.         scopeup(tq->U.V38.texpw);
  502.         checksymbol(*((symset *)Conset[124]));
  503.     } while (!(currsym.st == sdo));
  504.     tp->U.V37.twithstmt = plabstmt();
  505.     tq = tp->U.V37.twithvar;
  506.     while (tq != (struct S61 *)NIL) {
  507.         leavescope();
  508.         tq = tq->tnext;
  509.     }
  510.     R154 = tp;
  511.     return R154;
  512. }
  513.  
  514.  treeptr
  515. pgoto()
  516. {
  517.     register treeptr    R155;
  518.     treeptr    tp;
  519.  
  520.     nextsymbol(*((symset *)Conset[125]));
  521.     tp = mknode(ngoto);
  522.     tp->U.V26.tlabel = oldlbl(false);
  523.     nextsymbol(*((symset *)Conset[126]));
  524.     R155 = tp;
  525.     return R155;
  526. }
  527.  
  528.  treeptr
  529. pbegin(retain)
  530.     boolean    retain;
  531. {
  532.     register treeptr    R156;
  533.     treeptr    tp, tq;
  534.  
  535.     tq = (struct S61 *)NIL;
  536.     do {
  537.         if (tq == (struct S61 *)NIL) {
  538.             tq = plabstmt();
  539.             tp = tq;
  540.         } else {
  541.             tq->tnext = plabstmt();
  542.             tq = tq->tnext;
  543.         }
  544.     } while (!(currsym.st == send));
  545.     if (retain) {
  546.         tq = mknode(nbegin);
  547.         tq->U.V24.tbegin = tp;
  548.         tp = tq;
  549.     }
  550.     nextsymbol(*((symset *)Conset[127]));
  551.     R156 = tp;
  552.     return R156;
  553. }
  554.  
  555.  void
  556. parse()
  557. {
  558.     nextsymbol(*((symset *)Conset[128]));
  559.     if (currsym.st == spgm)
  560.         top = pprogram();
  561.     else
  562.         top = pmodule();
  563.     nextsymbol(*((symset *)Conset[129]));
  564. }
  565.  
  566.  integer
  567. cvalof(tp)
  568.     treeptr    tp;
  569. {
  570.     register integer    R157;
  571.     integer    v;
  572.     treeptr    tq;
  573.  
  574.     switch (tp->tt) {
  575.       case nuplus:
  576.         R157 = cvalof(tp->U.V42.texps);
  577.         break ;
  578.       case numinus:
  579.         R157 = -cvalof(tp->U.V42.texps);
  580.         break ;
  581.       case nnot:
  582.         R157 = 1 - cvalof(tp->U.V42.texps);
  583.         break ;
  584.       case nid:
  585.         tq = idup(tp);
  586.         if (tq == (struct S61 *)NIL)
  587.             fatal(etree);
  588.         tp = tp->U.V43.tsym->lsymdecl;
  589.         switch (tq->tt) {
  590.           case nscalar:
  591.             v = 0;
  592.             tq = tq->U.V17.tscalid;
  593.             while (tq != (struct S61 *)NIL)
  594.                 if (tq == tp)
  595.                     tq = (struct S61 *)NIL;
  596.                 else {
  597.                     v = v + 1;
  598.                     tq = tq->tnext;
  599.                 }
  600.             R157 = v;
  601.             break ;
  602.           case nconst:
  603.             R157 = cvalof(tq->U.V14.tbind);
  604.             break ;
  605.           default:
  606.             Caseerror(Line);
  607.         }
  608.         break ;
  609.       case ninteger:
  610.         R157 = tp->U.V43.tsym->U.V10.linum;
  611.         break ;
  612.       case nchar:
  613.         R157 = (unsigned)(tp->U.V43.tsym->U.V11.lchar);
  614.         break ;
  615.       default:
  616.         Caseerror(Line);
  617.     }
  618.     return R157;
  619. }
  620.  
  621.  integer
  622. clower(tp)
  623.     treeptr    tp;
  624. {
  625.     register integer    R158;
  626.     treeptr    tq;
  627.  
  628.     tq = typeof(tp);
  629.     if (tq->tt == nscalar)
  630.         R158 = scalbase;
  631.     else
  632.         if (tq->tt == nsubrange)
  633.             if (tq->tup->tt == nconfarr)
  634.                 R158 = 0;
  635.             else
  636.                 R158 = cvalof(tq->U.V19.tlo);
  637.         else
  638.             if (tq == typnods.A[(int)(tchar)])
  639.                 R158 = 0;
  640.             else
  641.                 if (tq == typnods.A[(int)(tinteger)])
  642.                     R158 = -maxint;
  643.                 else
  644.                     fatal(etree);
  645.     return R158;
  646. }
  647.  
  648.  integer
  649. cupper(tp)
  650.     treeptr    tp;
  651. {
  652.     register integer    R159;
  653.     treeptr    tq;
  654.     integer    i;
  655.  
  656.     tq = typeof(tp);
  657.     if (tq->tt == nscalar) {
  658.         tq = tq->U.V17.tscalid;
  659.         i = scalbase;
  660.         while (tq->tnext != (struct S61 *)NIL) {
  661.             i = i + 1;
  662.             tq = tq->tnext;
  663.         }
  664.         R159 = i;
  665.     } else
  666.         if (tq->tt == nsubrange)
  667.             if (tq->tup->tt == nconfarr)
  668.                 fatal(euprconf);
  669.             else
  670.                 R159 = cvalof(tq->U.V19.thi);
  671.         else
  672.             if (tq == typnods.A[(int)(tchar)])
  673.                 R159 = maxchar;
  674.             else
  675.                 if (tq == typnods.A[(int)(tinteger)])
  676.                     R159 = maxint;
  677.                 else
  678.                     fatal(etree);
  679.     return R159;
  680. }
  681.  
  682.  integer
  683. crange(tp)
  684.     treeptr    tp;
  685. {
  686.     register integer    R160;
  687.  
  688.     R160 = cupper(tp) - clower(tp) + 1;
  689.     return R160;
  690. }
  691.  
  692.  integer
  693. csetwords(i)
  694.     integer    i;
  695. {
  696.     register integer    R161;
  697.  
  698.     i = (i + (C37_setbits)) / (C37_setbits + 1);
  699.     if (i > maxsetrange)
  700.         error(esetsize);
  701.     R161 = i;
  702.     return R161;
  703. }
  704.  
  705.  integer
  706. csetsize(tp)
  707.     treeptr    tp;
  708. {
  709.     register integer    R162;
  710.     treeptr    tq;
  711.     integer    i;
  712.  
  713.     tq = typeof(tp->U.V18.tof);
  714.     i = clower(tq);
  715.     if ((i < 0) || (i >= 6 * (C37_setbits + 1)))
  716.         error(esetbase);
  717.     R162 = csetwords(crange(tq)) + 1;
  718.     return R162;
  719. }
  720.  
  721.  boolean
  722. islocal(tp)
  723.     treeptr    tp;
  724. {
  725.     register boolean    R163;
  726.     treeptr    tq;
  727.  
  728.     tq = tp->U.V43.tsym->lsymdecl;
  729.     while (!(Member((unsigned)(tq->tt), Conset[130])))
  730.         tq = tq->tup;
  731.     while (!(Member((unsigned)(tp->tt), Conset[131])))
  732.         tp = tp->tup;
  733.     R163 = (boolean)(tp == tq);
  734.     return R163;
  735. }
  736.  
  737. void transform();
  738.  
  739. void renamf();
  740.  
  741.  void
  742. crtnvar(tp)
  743.     treeptr    tp;
  744. {
  745.     while (tp != (struct S61 *)NIL) {
  746.         switch (tp->tt) {
  747.           case npgm:
  748.             crtnvar(tp->U.V13.tsubsub);
  749.             break ;
  750.           case nfunc:  case nproc:
  751.             crtnvar(tp->U.V13.tsubsub);
  752.             crtnvar(tp->U.V13.tsubstmt);
  753.             break ;
  754.           case nbegin:
  755.             crtnvar(tp->U.V24.tbegin);
  756.             break ;
  757.           case nif:
  758.             crtnvar(tp->U.V31.tthen);
  759.             crtnvar(tp->U.V31.telse);
  760.             break ;
  761.           case nwhile:
  762.             crtnvar(tp->U.V32.twhistmt);
  763.             break ;
  764.           case nrepeat:
  765.             crtnvar(tp->U.V33.treptstmt);
  766.             break ;
  767.           case nfor:
  768.             crtnvar(tp->U.V34.tforstmt);
  769.             break ;
  770.           case ncase:
  771.             crtnvar(tp->U.V35.tcaslst);
  772.             crtnvar(tp->U.V35.tcasother);
  773.             break ;
  774.           case nchoise:
  775.             crtnvar(tp->U.V36.tchostmt);
  776.             break ;
  777.           case nwith:
  778.             crtnvar(tp->U.V37.twithstmt);
  779.             break ;
  780.           case nlabstmt:
  781.             crtnvar(tp->U.V25.tstmt);
  782.             break ;
  783.           case nassign:
  784.             if (tp->U.V27.tlhs->tt == ncall) {
  785.                 tp->U.V27.tlhs = tp->U.V27.tlhs->U.V30.tcall;
  786.                 tp->U.V27.tlhs->tup = tp;
  787.             }
  788.             (*G187_tv) = tp->U.V27.tlhs;
  789.             if ((*G187_tv)->tt == nid)
  790.                 if ((*G187_tv)->U.V43.tsym == (*G183_ip))
  791.                     (*G187_tv)->U.V43.tsym = (*G185_iq);
  792.             break ;
  793.           case nbreak:  case npush:  case npop:  case ngoto:
  794.           case nempty:  case ncall:
  795.             break ;
  796.           default:
  797.             Caseerror(Line);
  798.         }
  799.         tp = tp->tnext;
  800.     }
  801. }
  802.  
  803.  void
  804. renamf(tp)
  805.     treeptr    tp;
  806. {
  807.     symptr    ip, iq;
  808.     treeptr    tq, tv;
  809.     symptr    *F184;
  810.     symptr    *F186;
  811.     treeptr    *F188;
  812.  
  813.     F188 = G187_tv;
  814.     G187_tv = &tv;
  815.     F186 = G185_iq;
  816.     G185_iq = &iq;
  817.     F184 = G183_ip;
  818.     G183_ip = &ip;
  819.     while (tp != (struct S61 *)NIL) {
  820.         switch (tp->tt) {
  821.           case npgm:  case nproc:
  822.             renamf(tp->U.V13.tsubsub);
  823.             break ;
  824.           case nfunc:
  825.             tq = mknode(nvar);
  826.             tq->U.V14.tattr = aregister;
  827.             tq->tup = tp;
  828.             tq->U.V14.tidl = newid(mkvariable('R'));
  829.             tq->U.V14.tidl->tup = tq;
  830.             tq->U.V14.tbind = tp->U.V13.tfuntyp;
  831.             tq->tnext = tp->U.V13.tsubvar;
  832.             tp->U.V13.tsubvar = tq;
  833.             (*G185_iq) = tq->U.V14.tidl->U.V43.tsym;
  834.             (*G183_ip) = tp->U.V13.tsubid->U.V43.tsym;
  835.             crtnvar(tp->U.V13.tsubsub);
  836.             crtnvar(tp->U.V13.tsubstmt);
  837.             renamf(tp->U.V13.tsubsub);
  838.             break ;
  839.           default:
  840.             Caseerror(Line);
  841.         }
  842.         tp = tp->tnext;
  843.     }
  844.     G183_ip = F184;
  845.     G185_iq = F186;
  846.     G187_tv = F188;
  847. }
  848.  
  849. void extract();
  850.  
  851.  treeptr
  852. xtrit(tp, pp, last)
  853.     treeptr    tp, pp;
  854.     boolean    last;
  855. {
  856.     register treeptr    R164;
  857.     treeptr    np, rp;
  858.     idptr    ip;
  859.  
  860.     np = mknode(ntype);
  861.     ip = mkvariable('T');
  862.     np->U.V14.tidl = newid(ip);
  863.     np->U.V14.tidl->tup = np;
  864.     rp = oldid(ip, lidentifier);
  865.     rp->tup = tp->tup;
  866.     rp->tnext = tp->tnext;
  867.     np->U.V14.tbind = tp;
  868.     tp->tup = np;
  869.     tp->tnext = (struct S61 *)NIL;
  870.     np->tup = pp;
  871.     if (last && (pp->U.V13.tsubtype != (struct S61 *)NIL)) {
  872.         pp = pp->U.V13.tsubtype;
  873.         while (pp->tnext != (struct S61 *)NIL)
  874.             pp = pp->tnext;
  875.         pp->tnext = np;
  876.     } else {
  877.         np->tnext = pp->U.V13.tsubtype;
  878.         pp->U.V13.tsubtype = np;
  879.     }
  880.     R164 = rp;
  881.     return R164;
  882. }
  883.  
  884. treeptr xtrenum();
  885.  
  886.  void
  887. nametype(tp)
  888.     treeptr    tp;
  889. {
  890.     tp = typeof(tp);
  891.     if (tp->tt == nrecord)
  892.         if (tp->U.V21.tuid == (struct S59 *)NIL)
  893.             tp->U.V21.tuid = mkvariable('S');
  894. }
  895.  
  896.  treeptr
  897. xtrenum(tp, pp)
  898.     treeptr    tp, pp;
  899. {
  900.     register treeptr    R165;
  901.  
  902.     if (tp != (struct S61 *)NIL) {
  903.         switch (tp->tt) {
  904.           case nfield:  case ntype:  case nvar:
  905.             tp->U.V14.tbind = xtrenum(tp->U.V14.tbind, pp);
  906.             break ;
  907.           case nscalar:
  908.             if (tp->tup->tt != ntype)
  909.                 tp = xtrit(tp, pp, false);
  910.             break ;
  911.           case narray:
  912.             tp->U.V23.taindx = xtrenum(tp->U.V23.taindx, pp);
  913.             tp->U.V23.taelem = xtrenum(tp->U.V23.taelem, pp);
  914.             break ;
  915.           case nrecord:
  916.             tp->U.V21.tflist = xtrenum(tp->U.V21.tflist, pp);
  917.             tp->U.V21.tvlist = xtrenum(tp->U.V21.tvlist, pp);
  918.             break ;
  919.           case nvariant:
  920.             tp->U.V20.tvrnt = xtrenum(tp->U.V20.tvrnt, pp);
  921.             break ;
  922.           case nfileof:
  923.             tp->U.V18.tof = xtrenum(tp->U.V18.tof, pp);
  924.             break ;
  925.           case nptr:
  926.             nametype(tp->U.V16.tptrid);
  927.             break ;
  928.           case nid:  case nsubrange:  case npredef:  case nempty:
  929.           case nsetof:
  930.             break ;
  931.           default:
  932.             Caseerror(Line);
  933.         }
  934.         tp->tnext = xtrenum(tp->tnext, pp);
  935.     }
  936.     R165 = tp;
  937.     return R165;
  938. }
  939.  
  940.  void
  941. extract(tp)
  942.     treeptr    tp;
  943. {
  944.     treeptr    vp;
  945.  
  946.     while (tp != (struct S61 *)NIL) {
  947.         tp->U.V13.tsubtype = xtrenum(tp->U.V13.tsubtype, tp);
  948.         tp->U.V13.tsubvar = xtrenum(tp->U.V13.tsubvar, tp);
  949.         vp = tp->U.V13.tsubvar;
  950.         while (vp != (struct S61 *)NIL) {
  951.             if (Member((unsigned)(vp->U.V14.tbind->tt), Conset[132]))
  952.                 vp->U.V14.tbind = xtrit(vp->U.V14.tbind, tp, true);
  953.             vp = vp->tnext;
  954.         }
  955.         extract(tp->U.V13.tsubsub);
  956.         tp = tp->tnext;
  957.     }
  958. }
  959.  
  960. void global();
  961.  
  962.  void
  963. markdecl(xp)
  964.     treeptr    xp;
  965. {
  966.     while (xp != (struct S61 *)NIL) {
  967.         switch (xp->tt) {
  968.           case nid:
  969.             xp->U.V43.tsym->U.V6.lused = false;
  970.             break ;
  971.           case nconst:
  972.             markdecl(xp->U.V14.tidl);
  973.             break ;
  974.           case ntype:  case nvar:  case nvalpar:  case nvarpar:
  975.           case nfield:
  976.             markdecl(xp->U.V14.tidl);
  977.             if (xp->U.V14.tbind->tt != nid)
  978.                 markdecl(xp->U.V14.tbind);
  979.             break ;
  980.           case nscalar:
  981.             markdecl(xp->U.V17.tscalid);
  982.             break ;
  983.           case nrecord:
  984.             markdecl(xp->U.V21.tflist);
  985.             markdecl(xp->U.V21.tvlist);
  986.             break ;
  987.           case nvariant:
  988.             markdecl(xp->U.V20.tvrnt);
  989.             break ;
  990.           case nconfarr:
  991.             if (xp->U.V22.tcelem->tt != nid)
  992.                 markdecl(xp->U.V22.tcelem);
  993.             break ;
  994.           case narray:
  995.             if (xp->U.V23.taelem->tt != nid)
  996.                 markdecl(xp->U.V23.taelem);
  997.             break ;
  998.           case nsetof:  case nfileof:
  999.             if (xp->U.V18.tof->tt != nid)
  1000.                 markdecl(xp->U.V18.tof);
  1001.             break ;
  1002.           case nparproc:  case nparfunc:
  1003.             markdecl(xp->U.V15.tparid);
  1004.             break ;
  1005.           case nptr:  case nsubrange:
  1006.             break ;
  1007.           default:
  1008.             Caseerror(Line);
  1009.         }
  1010.         xp = xp->tnext;
  1011.     }
  1012. }
  1013.  
  1014.  treeptr
  1015. movedecl(tp)
  1016.     treeptr    tp;
  1017. {
  1018.     register treeptr    R166;
  1019.     treeptr    ip, np;
  1020.     symptr    sp;
  1021.     boolean    move;
  1022.  
  1023.     if (tp != (struct S61 *)NIL) {
  1024.         move = false;
  1025.         switch (tp->tt) {
  1026.           case nconst:  case ntype:
  1027.             ip = tp->U.V14.tidl;
  1028.             break ;
  1029.           default:
  1030.             Caseerror(Line);
  1031.         }
  1032.         while (ip != (struct S61 *)NIL) {
  1033.             if (ip->U.V43.tsym->U.V6.lused) {
  1034.                 move = true;
  1035.                 sp = ip->U.V43.tsym;
  1036.                 if (sp->U.V6.lid->inref > 1) {
  1037.                     sp->U.V6.lid = mkrename('M', sp->U.V6.lid);
  1038.                     sp->U.V6.lid->inref = sp->U.V6.lid->inref - 1;
  1039.                 }
  1040.                 ip = (struct S61 *)NIL;
  1041.             } else
  1042.                 ip = ip->tnext;
  1043.         }
  1044.         if (move) {
  1045.             np = tp->tnext;
  1046.             tp->tnext = (struct S61 *)NIL;
  1047.             ip = tp;
  1048.             while (ip->tt != npgm)
  1049.                 ip = ip->tup;
  1050.             tp->tup = ip;
  1051.             switch (tp->tt) {
  1052.               case nconst:
  1053.                 if (ip->U.V13.tsubconst == (struct S61 *)NIL)
  1054.                     ip->U.V13.tsubconst = tp;
  1055.                 else {
  1056.                     ip = ip->U.V13.tsubconst;
  1057.                     while (ip->tnext != (struct S61 *)NIL)
  1058.                         ip = ip->tnext;
  1059.                     ip->tnext = tp;
  1060.                 }
  1061.                 break ;
  1062.               case ntype:
  1063.                 if (ip->U.V13.tsubtype == (struct S61 *)NIL)
  1064.                     ip->U.V13.tsubtype = tp;
  1065.                 else {
  1066.                     ip = ip->U.V13.tsubtype;
  1067.                     while (ip->tnext != (struct S61 *)NIL)
  1068.                         ip = ip->tnext;
  1069.                     ip->tnext = tp;
  1070.                 }
  1071.                 break ;
  1072.               default:
  1073.                 Caseerror(Line);
  1074.             }
  1075.             tp = movedecl(np);
  1076.         } else
  1077.             tp->tnext = movedecl(tp->tnext);
  1078.     }
  1079.     R166 = tp;
  1080.     return R166;
  1081. }
  1082.  
  1083. void movevars();
  1084.  
  1085.  void
  1086. moveglob(tp, dp)
  1087.     treeptr    tp, dp;
  1088. {
  1089.     while (tp->tt != npgm)
  1090.         tp = tp->tup;
  1091.     dp->tup = tp;
  1092.     dp->tnext = tp->U.V13.tsubvar;
  1093.     tp->U.V13.tsubvar = dp;
  1094. }
  1095.  
  1096.  treeptr
  1097. stackop(decl, glob, loc)
  1098.     treeptr    decl, glob, loc;
  1099. {
  1100.     register treeptr    R167;
  1101.     treeptr    op, ip, dp, tp;
  1102.  
  1103.     ip = newid(mkvariable('F'));
  1104.     switch ((*G189_vp)->tt) {
  1105.       case nvarpar:  case nvalpar:  case nvar:
  1106.         dp = mknode(nvarpar);
  1107.         dp->U.V14.tattr = areference;
  1108.         dp->U.V14.tidl = ip;
  1109.         dp->U.V14.tbind = decl->U.V14.tbind;
  1110.         break ;
  1111.       case nparproc:  case nparfunc:
  1112.         dp = mknode((*G189_vp)->tt);
  1113.         dp->U.V15.tparid = ip;
  1114.         dp->U.V15.tparparm = (struct S61 *)NIL;
  1115.         dp->U.V15.tpartyp = (*G189_vp)->U.V15.tpartyp;
  1116.         break ;
  1117.       default:
  1118.         Caseerror(Line);
  1119.     }
  1120.     ip->tup = dp;
  1121.     tp = decl;
  1122.     while (!(Member((unsigned)(tp->tt), Conset[133])))
  1123.         tp = tp->tup;
  1124.     dp->tup = tp;
  1125.     if (tp->U.V13.tsubvar == (struct S61 *)NIL)
  1126.         tp->U.V13.tsubvar = dp;
  1127.     else {
  1128.         tp = tp->U.V13.tsubvar;
  1129.         while (tp->tnext != (struct S61 *)NIL)
  1130.             tp = tp->tnext;
  1131.         tp->tnext = dp;
  1132.     }
  1133.     dp->tnext = (struct S61 *)NIL;
  1134.     op = mknode(npush);
  1135.     op->U.V28.tglob = glob;
  1136.     op->U.V28.tloc = loc;
  1137.     op->U.V28.ttmp = ip;
  1138.     R167 = op;
  1139.     return R167;
  1140. }
  1141.  
  1142.  void
  1143. addcode(tp, push)
  1144.     treeptr    tp, push;
  1145. {
  1146.     treeptr    pop;
  1147.  
  1148.     pop = mknode(npop);
  1149.     pop->U.V28.tglob = push->U.V28.tglob;
  1150.     pop->U.V28.ttmp = push->U.V28.ttmp;
  1151.     pop->U.V28.tloc = (struct S61 *)NIL;
  1152.     push->tnext = tp->U.V13.tsubstmt;
  1153.     tp->U.V13.tsubstmt = push;
  1154.     push->tup = tp;
  1155.     while (push->tnext != (struct S61 *)NIL)
  1156.         push = push->tnext;
  1157.     push->tnext = pop;
  1158.     pop->tup = tp;
  1159. }
  1160.  
  1161.  void
  1162. movevars(tp, vp)
  1163.     treeptr    tp, vp;
  1164. {
  1165.     treeptr    ep, dp, np;
  1166.     idptr    ip;
  1167.     symptr    sp;
  1168.     treeptr    *F190;
  1169.  
  1170.     F190 = G189_vp;
  1171.     G189_vp = &vp;
  1172.     while ((*G189_vp) != (struct S61 *)NIL) {
  1173.         switch ((*G189_vp)->tt) {
  1174.           case nvar:  case nvalpar:  case nvarpar:
  1175.             dp = (*G189_vp)->U.V14.tidl;
  1176.             break ;
  1177.           case nparproc:  case nparfunc:
  1178.             dp = (*G189_vp)->U.V15.tparid;
  1179.             if (dp->U.V43.tsym->U.V6.lused) {
  1180.                 ep = mknode((*G189_vp)->tt);
  1181.                 ep->U.V15.tparparm = (struct S61 *)NIL;
  1182.                 ep->U.V15.tpartyp = (*G189_vp)->U.V15.tpartyp;
  1183.                 np = newid(mkrename('G', dp->U.V43.tsym->U.V6.lid));
  1184.                 ep->U.V15.tparid = np;
  1185.                 np->tup = ep;
  1186.                 sp = np->U.V43.tsym;
  1187.                 ip = sp->U.V6.lid;
  1188.                 np->U.V43.tsym->U.V6.lid = dp->U.V43.tsym->U.V6.lid;
  1189.                 dp->U.V43.tsym->U.V6.lid = ip;
  1190.                 np->U.V43.tsym = dp->U.V43.tsym;
  1191.                 dp->U.V43.tsym = sp;
  1192.                 np->U.V43.tsym->lsymdecl = np;
  1193.                 dp->U.V43.tsym->lsymdecl = dp;
  1194.                 moveglob(tp, ep);
  1195.                 addcode(tp, stackop((*G189_vp), np, dp));
  1196.             }
  1197.             goto L555;
  1198.             break ;
  1199.           default:
  1200.             Caseerror(Line);
  1201.         }
  1202.         while (dp != (struct S61 *)NIL) {
  1203.             if (dp->U.V43.tsym->U.V6.lused) {
  1204.                 ep = mknode(nvarpar);
  1205.                 ep->U.V14.tattr = areference;
  1206.                 np = newid(mkrename('G', dp->U.V43.tsym->U.V6.lid));
  1207.                 ep->U.V14.tidl = np;
  1208.                 np->tup = ep;
  1209.                 ep->U.V14.tbind = (*G189_vp)->U.V14.tbind;
  1210.                 if (ep->U.V14.tbind->tt == nid)
  1211.                     ep->U.V14.tbind->U.V43.tsym->U.V6.lused = true;
  1212.                 sp = np->U.V43.tsym;
  1213.                 ip = sp->U.V6.lid;
  1214.                 np->U.V43.tsym->U.V6.lid = dp->U.V43.tsym->U.V6.lid;
  1215.                 dp->U.V43.tsym->U.V6.lid = ip;
  1216.                 np->U.V43.tsym = dp->U.V43.tsym;
  1217.                 dp->U.V43.tsym = sp;
  1218.                 np->U.V43.tsym->lsymdecl = np;
  1219.                 dp->U.V43.tsym->lsymdecl = dp;
  1220.                 dp->tup->U.V14.tattr = aextern;
  1221.                 moveglob(tp, ep);
  1222.                 addcode(tp, stackop((*G189_vp), np, dp));
  1223.             }
  1224.             dp = dp->tnext;
  1225.         }
  1226.     L555:
  1227.         (*G189_vp) = (*G189_vp)->tnext;
  1228.     }
  1229.     G189_vp = F190;
  1230. }
  1231.  
  1232.  void
  1233. registervar(tp)
  1234.     treeptr    tp;
  1235. {
  1236.     treeptr    vp, xp;
  1237.  
  1238.     vp = idup(tp);
  1239.     tp = tp->U.V43.tsym->lsymdecl;
  1240.     if ((vp->U.V14.tidl != tp) || (tp->tnext != (struct S61 *)NIL)) {
  1241.         xp = mknode(nvar);
  1242.         xp->U.V14.tattr = anone;
  1243.         xp->U.V14.tidl = tp;
  1244.         tp->tup = xp;
  1245.         xp->tup = vp->tup;
  1246.         xp->U.V14.tbind = vp->U.V14.tbind;
  1247.         xp->tnext = vp->tnext;
  1248.         vp->tnext = xp;
  1249.         if (vp->U.V14.tidl == tp)
  1250.             vp->U.V14.tidl = tp->tnext;
  1251.         else {
  1252.             vp = vp->U.V14.tidl;
  1253.             while (vp->tnext != tp)
  1254.                 vp = vp->tnext;
  1255.             vp->tnext = tp->tnext;
  1256.         }
  1257.         tp->tnext = (struct S61 *)NIL;
  1258.     }
  1259.     if (tp->tup->U.V14.tattr == anone)
  1260.         tp->tup->U.V14.tattr = aregister;
  1261. }
  1262.  
  1263.  void
  1264. cklevel(tp)
  1265.     treeptr    tp;
  1266. {
  1267.     tp = tp->U.V43.tsym->lsymdecl;
  1268.     while (!(Member((unsigned)(tp->tt), Conset[134])))
  1269.         tp = tp->tup;
  1270.     if (tp->U.V13.tstat > maxlevel)
  1271.         maxlevel = tp->U.V13.tstat;
  1272. }
  1273.  
  1274.  void
  1275. global(tp, dp, depend)
  1276.     treeptr    tp, dp;
  1277.     boolean    depend;
  1278. {
  1279.     treeptr    ip;
  1280.     boolean    dep;
  1281.  
  1282.     while (tp != (struct S61 *)NIL) {
  1283.         switch (tp->tt) {
  1284.           case nproc:  case nfunc:
  1285.             markdecl(tp->U.V13.tsubid);
  1286.             markdecl(tp->U.V13.tsubpar);
  1287.             markdecl(tp->U.V13.tsubconst);
  1288.             markdecl(tp->U.V13.tsubtype);
  1289.             markdecl(tp->U.V13.tsubvar);
  1290.             global(tp->U.V13.tsubsub, tp, false);
  1291.             movevars(tp, tp->U.V13.tsubpar);
  1292.             movevars(tp, tp->U.V13.tsubvar);
  1293.             tp->U.V13.tsubtype = movedecl(tp->U.V13.tsubtype);
  1294.             tp->U.V13.tsubconst = movedecl(tp->U.V13.tsubconst);
  1295.             global(tp->U.V13.tsubstmt, tp, true);
  1296.             global(tp->U.V13.tsubpar, tp, false);
  1297.             global(tp->U.V13.tsubvar, tp, false);
  1298.             global(tp->U.V13.tsubtype, tp, false);
  1299.             global(tp->U.V13.tfuntyp, tp, false);
  1300.             break ;
  1301.           case npgm:
  1302.             markdecl(tp->U.V13.tsubconst);
  1303.             markdecl(tp->U.V13.tsubtype);
  1304.             markdecl(tp->U.V13.tsubvar);
  1305.             global(tp->U.V13.tsubsub, tp, false);
  1306.             global(tp->U.V13.tsubstmt, tp, true);
  1307.             break ;
  1308.           case nconst:  case ntype:  case nvar:  case nfield:
  1309.           case nvalpar:  case nvarpar:
  1310.             ip = tp->U.V14.tidl;
  1311.             dep = depend;
  1312.             while ((ip != (struct S61 *)NIL) && !dep) {
  1313.                 if (ip->U.V43.tsym->U.V6.lused)
  1314.                     dep = true;
  1315.                 ip = ip->tnext;
  1316.             }
  1317.             global(tp->U.V14.tbind, dp, dep);
  1318.             break ;
  1319.           case nparproc:  case nparfunc:
  1320.             global(tp->U.V15.tparparm, dp, depend);
  1321.             global(tp->U.V15.tpartyp, dp, depend);
  1322.             break ;
  1323.           case nsubrange:
  1324.             global(tp->U.V19.tlo, dp, depend);
  1325.             global(tp->U.V19.thi, dp, depend);
  1326.             break ;
  1327.           case nvariant:
  1328.             global(tp->U.V20.tselct, dp, depend);
  1329.             global(tp->U.V20.tvrnt, dp, depend);
  1330.             break ;
  1331.           case nrecord:
  1332.             global(tp->U.V21.tflist, dp, depend);
  1333.             global(tp->U.V21.tvlist, dp, depend);
  1334.             break ;
  1335.           case nconfarr:
  1336.             global(tp->U.V22.tcindx, dp, depend);
  1337.             global(tp->U.V22.tcelem, dp, depend);
  1338.             break ;
  1339.           case narray:
  1340.             global(tp->U.V23.taindx, dp, depend);
  1341.             global(tp->U.V23.taelem, dp, depend);
  1342.             break ;
  1343.           case nfileof:  case nsetof:
  1344.             global(tp->U.V18.tof, dp, depend);
  1345.             break ;
  1346.           case nptr:
  1347.             global(tp->U.V16.tptrid, dp, depend);
  1348.             break ;
  1349.           case nscalar:
  1350.             global(tp->U.V17.tscalid, dp, depend);
  1351.             break ;
  1352.           case nbegin:
  1353.             global(tp->U.V24.tbegin, dp, depend);
  1354.             break ;
  1355.           case nif:
  1356.             global(tp->U.V31.tifxp, dp, depend);
  1357.             global(tp->U.V31.tthen, dp, depend);
  1358.             global(tp->U.V31.telse, dp, depend);
  1359.             break ;
  1360.           case nwhile:
  1361.             global(tp->U.V32.twhixp, dp, depend);
  1362.             global(tp->U.V32.twhistmt, dp, depend);
  1363.             break ;
  1364.           case nrepeat:
  1365.             global(tp->U.V33.treptstmt, dp, depend);
  1366.             global(tp->U.V33.treptxp, dp, depend);
  1367.             break ;
  1368.           case nfor:
  1369.             ip = idup(tp->U.V34.tforid);
  1370.             if (Member((unsigned)(ip->tup->tt), Conset[135]))
  1371.                 registervar(tp->U.V34.tforid);
  1372.             global(tp->U.V34.tforid, dp, depend);
  1373.             global(tp->U.V34.tfrom, dp, depend);
  1374.             global(tp->U.V34.tto, dp, depend);
  1375.             global(tp->U.V34.tforstmt, dp, depend);
  1376.             break ;
  1377.           case ncase:
  1378.             global(tp->U.V35.tcasxp, dp, depend);
  1379.             global(tp->U.V35.tcaslst, dp, depend);
  1380.             global(tp->U.V35.tcasother, dp, depend);
  1381.             break ;
  1382.           case nchoise:
  1383.             global(tp->U.V36.tchocon, dp, depend);
  1384.             global(tp->U.V36.tchostmt, dp, depend);
  1385.             break ;
  1386.           case nwith:
  1387.             global(tp->U.V37.twithvar, dp, depend);
  1388.             global(tp->U.V37.twithstmt, dp, depend);
  1389.             break ;
  1390.           case nwithvar:
  1391.             ip = typeof(tp->U.V38.texpw);
  1392.             if (ip->U.V21.tuid == (struct S59 *)NIL)
  1393.                 ip->U.V21.tuid = mkvariable('S');
  1394.             global(tp->U.V38.texpw, dp, depend);
  1395.             break ;
  1396.           case nlabstmt:
  1397.             global(tp->U.V25.tstmt, dp, depend);
  1398.             break ;
  1399.           case neq:  case nne:  case nlt:  case nle:
  1400.           case ngt:  case nge:
  1401.             global(tp->U.V41.texpl, dp, depend);
  1402.  
  1403.             global(tp->U.V41.texpr, dp, depend);
  1404.             ip = typeof(tp->U.V41.texpl);
  1405.             if ((ip == typnods.A[(int)(tstring)]) || (ip->tt == narray))
  1406.                 usecomp = true;
  1407.             ip = typeof(tp->U.V41.texpr);
  1408.             if ((ip == typnods.A[(int)(tstring)]) || (ip->tt == narray))
  1409.                 usecomp = true;
  1410.             break ;
  1411.           case nin:  case nor:  case nplus:  case nminus:
  1412.           case nand:  case nmul:  case ndiv:  case nmod:
  1413.           case nquot:  case nformat:  case nrange:
  1414.             global(tp->U.V41.texpl, dp, depend);
  1415.             global(tp->U.V41.texpr, dp, depend);
  1416.             break ;
  1417.           case nassign:
  1418.             global(tp->U.V27.tlhs, dp, depend);
  1419.             global(tp->U.V27.trhs, dp, depend);
  1420.             break ;
  1421.           case nnot:  case numinus:  case nuplus:  case nderef:
  1422.             global(tp->U.V42.texps, dp, depend);
  1423.             break ;
  1424.           case nset:
  1425.             global(tp->U.V42.texps, dp, depend);
  1426.             break ;
  1427.           case nindex:
  1428.             global(tp->U.V39.tvariable, dp, depend);
  1429.             global(tp->U.V39.toffset, dp, depend);
  1430.             break ;
  1431.           case nselect:
  1432.             global(tp->U.V40.trecord, dp, depend);
  1433.             break ;
  1434.           case ncall:
  1435.             global(tp->U.V30.tcall, dp, depend);
  1436.             global(tp->U.V30.taparm, dp, depend);
  1437.             break ;
  1438.           case nid:
  1439.             ip = idup(tp);
  1440.             if (ip == (struct S61 *)NIL)
  1441.                 goto L555;
  1442.             do {
  1443.                 ip = ip->tup;
  1444.                 if (ip == (struct S61 *)NIL)
  1445.                     goto L555;
  1446.             } while (!(Member((unsigned)(ip->tt), Conset[136])));
  1447.             if (dp == ip) {
  1448.                 if (depend)
  1449.                     tp->U.V43.tsym->U.V6.lused = true;
  1450.             } else {
  1451.                 tp->U.V43.tsym->U.V6.lused = true;
  1452.             }
  1453.         L555:
  1454.             ;
  1455.             break ;
  1456.           case ngoto:
  1457.             if (!islocal(tp->U.V26.tlabel)) {
  1458.                 tp->U.V26.tlabel->U.V43.tsym->U.V9.lgo = true;
  1459.                 usejmps = true;
  1460.                 cklevel(tp->U.V26.tlabel);
  1461.             }
  1462.             break ;
  1463.           case nbreak:  case npush:  case npop:  case npredef:
  1464.           case nempty:  case nchar:  case ninteger:  case nreal:
  1465.           case nstring:  case nnil:
  1466.             break ;
  1467.           default:
  1468.             Caseerror(Line);
  1469.         }
  1470.         tp = tp->tnext;
  1471.     }
  1472. }
  1473.  
  1474.  void
  1475. renamc()
  1476. {
  1477.     idptr    ip;
  1478.     register cnames    cn;
  1479.  
  1480.     {
  1481.         cnames    B49 = cabort,
  1482.             B50 = cwrite;
  1483.  
  1484.         if ((int)(B49) <= (int)(B50))
  1485.             for (cn = B49; ; cn = (cnames)((int)(cn)+1)) {
  1486.                 ip = mkrename('C', ctable.A[(int)(cn)]);
  1487.                 ctable.A[(int)(cn)]->istr = ip->istr;
  1488.                 if (cn == B50) break;
  1489.             }
  1490.     }
  1491. }
  1492.  
  1493.  void
  1494. renamp(tp, on)
  1495.     treeptr    tp;
  1496.     boolean    on;
  1497. {
  1498.     symptr    sp;
  1499.  
  1500.     while (tp != (struct S61 *)NIL) {
  1501.